// src/store/modules/chat.js
import { onWsEvent, sendWsMessage, getSocketInstance } from '@/services/websocket';
import { formatTime } from '@/util/get-time'
import { Message } from 'element-ui';

const state = {
  socket: null,
  // 连接状态（映射WebSocket服务的状态）
  wsState: 'disconnected', // connected/connecting/disconnected
  // 联系人数据
  offlineContacts: [], // 离线消息联系人
  historyContacts: [], // 历史聊天联系
  // 临时输入状态
  chatInput: '',
  // 系统消息（连接状态提示等）
  systemMessages: [],
  notifications: [], // 新增：通知列表
  historyChanged: false,
  recruiterOnlineUsers: [], // 新增：招聘者在线用户列表(对象)
  seekerOnlineUsers: [], // 新增：求职者在线用户列表(对象)

};

const getters = {
  // 连接状态文本（供UI显示）
  connectionStatus: (state) => {
    const statusMap = {
      connected: '已连接',
      connecting: '连接中...',
      disconnected: '已断开'
    };
    return statusMap[state.wsState] || '未知状态';
  },
  // 筛选后的离线联系人（根据搜索关键词）
  filteredOfflineContacts: (state) => (searchKeyword) => {
    if (!searchKeyword) return state.offlineContacts;
    return state.offlineContacts.filter(contact =>
      contact.contactUserId.toString().includes(searchKeyword) ||
      contact.lastMessage.includes(searchKeyword)
    );
  },
  // 筛选后的历史联系人
  filteredHistoryContacts: (state) => (searchKeyword) => {
    if (!searchKeyword) return state.historyContacts;
    return state.historyContacts.filter(contact =>
      contact.contactUserId.toString().includes(searchKeyword) ||
      contact.lastMessage.includes(searchKeyword)
    );
  },
  // 当前选中联系人的消息（按时间倒序）
  currentContactMessages: (state) => {
    if (!state.selectedContact) return [];
    // 复制数组避免修改原数据，按时间倒序
    return [...state.selectedContact.messages].sort((a, b) =>
      new Date(b.createdAt) - new Date(a.createdAt)
    );
  }
};

const mutations = {
  // 新增：更新WebSocket实例
  SET_SOCKET(state, socket) {
    state.socket = socket;
  },
  // 更新WebSocket连接状态
  SET_WS_STATE(state, status) {
    state.wsState = status;
  },
  // 更新离线联系人
  SET_OFFLINE_CONTACTS(state, contacts) {
    state.offlineContacts = contacts;
  },
  // 更新历史联系人
  SET_HISTORY_CONTACTS(state, contacts) {
    state.historyContacts = contacts;
  },
  // 给当前选中联系人添加临时消息（新增：不存在则创建联系人）
  ADD_MESSAGE_TO_SELECTED(state, message) {
    const tempMessage = {
      ...message,
      status: 'sending', // 临时状态：发送中
      tempId: Date.now() // 生成临时 ID
    };

    const targetContactId = tempMessage.toUserId;
    // 过滤掉目标联系人（如果存在）
    const filteredContacts = state.historyContacts.filter(item => item.id !== targetContactId);

    // 检查原列表中是否存在该联系人
    const existingContact = state.historyContacts.find(item => item.id === targetContactId);

    let updatedContact;
    if (existingContact) {
      // 联系人已存在：更新消息列表（新消息放第一位）
      updatedContact = {
        ...existingContact,
        messages: [tempMessage, ...existingContact.messages], // 新消息置顶
        lastMessage: tempMessage.message,
        lastMessageTime: tempMessage.createdAt
      };
    } else {
      // 联系人不存在：创建新联系人
      updatedContact = {
        id: targetContactId,
        userRelatedMessageResp: {
          userId: tempMessage.fromUserId,
          avatar: '', // 可替换为实际头像
          name: `用户${targetContactId}` // 可替换为实际名称
        },
        messages: [tempMessage],
        lastMessage: tempMessage.message,
        lastMessageTime: tempMessage.createdAt,
        unreadCount: 0,
        unread: false
      };
    }

    // 将更新后的联系人放在列表第一位，其余联系人跟在后面
    state.historyContacts = [updatedContact, ...filteredContacts];
  },
  // 更新消息状态
  UPDATE_MESSAGE_STATUS(state, { tempId, status }) {
    state.historyContacts = state.historyContacts.map(contact => {
      // 遍历联系人的消息数组，找到临时消息并更新状态
      const updatedMessages = contact.messages.map(msg => {
        if (msg.tempId === tempId) {
          return { ...msg, status };
        }
        return msg;
      });
      return { ...contact, messages: updatedMessages };
    });
  },
  // 回滚消息（发送失败时移除临时消息）
  ROLLBACK_MESSAGE(state, tempId) {
    state.historyContacts = state.historyContacts.map(contact => {
      // 过滤掉临时消息
      const filteredMessages = contact.messages.filter(msg => msg.tempId !== tempId);
      return { ...contact, messages: filteredMessages };
    });
  },
  // 添加系统消息
  ADD_SYSTEM_MESSAGE(state, content) {
    state.systemMessages.push({
      time: new Date().toISOString(),
      content
    });
  },

  //添加在线新消息到对应联系人
  ADD_ONLINE_MESSAGE(state, newMessage) {
    // 1. 找到消息对应的联系人（通过 fromUserId，因为消息是对方发来的）
    const contactId = newMessage.fromUserId; // 对方的ID即联系人ID
    const targetContact = state.historyContacts.find(item => item.id === contactId);

    if (targetContact) {
      // 2. 如果联系人已存在：直接添加消息到该联系人的消息列表
      state.historyContacts = state.historyContacts.map(contact => {
        if (contact.id === contactId) {
          return {
            ...contact,
            messages: [...contact.messages, newMessage], // 添加新消息
            lastMessage: newMessage.message, // 更新最后一条消息
            lastMessageTime: newMessage.createdAt, // 更新最后消息时间
            unreadCount: contact.unreadCount + 1, // 未读计数+1（如果不在当前聊天窗口）
            unread: true // 标记为有未读消息
          };
        }
        return contact;
      });
    } else {
      // 3. 如果联系人不存在（首次聊天）：创建新联系人并添加消息
      const newContact = {
        id: contactId,
        userRelatedMessageResp: newMessage.userRelatedMessageResp, // 可补充对方头像等信息
        messages: [newMessage], // 消息列表初始化为当前消息
        lastMessage: newMessage.message,
        lastMessageTime: newMessage.createdAt,
        unreadCount: 1, // 新联系人默认1条未读
        unread: true
      };
      // 添加到历史联系人列表
      state.historyContacts = [...state.historyContacts, newContact];
    }
  },

  // 添加通知
  ADD_NOTIFICATION(state, notification) {
    state.notifications.push({
      id: Date.now(),
      ...notification
    });
  },

  // 清除通知
  CLEAR_NOTIFICATION(state, id) {
    state.notifications = state.notifications.filter(n => n.id !== id);
  },

  // 更新招聘者在线用户列表
  SET_ONLINE_USERS(state, users) {
    state.recruiterOnlineUsers = users;
  },
  // 更新求职者在线用户列表
  SET_CANDIDATE_ONLINE_USERS(state, users) {
    state.seekerOnlineUsers = users;
  },

};

const actions = {
  // 初始化聊天模块（在应用启动/登录后调用）
  async initChatModule({ commit, state, rootDispatch, dispatch }) {

    // 1. 监听WebSocket状态变化（更新到Vuex）
    onWsEvent('stateChange', (status) => {
      commit('SET_WS_STATE', status);
    });

    // 2. 监听WebSocket消息（处理业务逻辑）
    onWsEvent('message', async (data) => {
      if (data.messageType === 'CHAT_RECORD') {
        // 收到历史聊天记录 -> 解析为联系人
        commit('SET_OFFLINE_CONTACTS', []); // 先清空旧数据
        commit('SET_HISTORY_CONTACTS', []);
        console.log('收到服务端消息测试点3：', data);
        try {
          await dispatch('parseChatRecords', data.message);
        } catch (error) {
          console.error('Failed to parse chat records:', error);
        }
      } else if (data.messageType === 'TEXT') {
        dispatch('handleOnlineMessage', data);
      } else if (data.messageType === 'ONLINE_USERS') {

        // 收到在线用户列表
        const obj = data.message;
        const recruiterUser = [];
        const seekerUser = [];

        for (const id in obj) {
          if (obj[id] === "recruiter") {
            recruiterUser.push(id);
          } else if (obj[id] === "seeker") {
            seekerUser.push(id);
          }
        }
        commit('SET_ONLINE_USERS', recruiterUser);
        commit('SET_CANDIDATE_ONLINE_USERS', seekerUser);

      } else if (data.messageType === 'REMOTE_LOGIN_ERROR') {
        Message.error('其他账户登录');
        await dispatch('seeker/logout', null, { root: true });

      }

    });

    // 3. 监听系统消息（连接提示等）
    onWsEvent('systemMessage', (data) => {
      console.log('看看系统消息', data);
      commit('ADD_SYSTEM_MESSAGE', data);
    });


    // 4. 关键：将WebSocket实例同步到Vuex
    const socket = getSocketInstance();
    if (socket) {
      commit('SET_SOCKET', socket);
    }
  },

  // 解析聊天记录为联系人列表
  async parseChatRecords({ commit }, chatRecords) {
    const offlineMap = {};
    const historyList = [];

    chatRecords.forEach(contactItem => {
      const messages = contactItem.messageSendRespList || [];
      if (!messages.length) return;

      // 计算未读消息数量（online为false的消息）
      const unreadCount = messages.filter(msg => !msg.online).length;
      const lastMsg = messages[messages.length - 1];

      const contact = {
        id: contactItem.contactUserId,
        userRelatedMessageResp: contactItem.userRelatedMessageResp,
        messages,
        lastMessage: lastMsg.message,
        lastMessageTime: lastMsg.createdAt,
        unreadCount, // 未读消息数量
        unread: unreadCount > 0 // 只要有一条未读消息，该联系人就是离线状态
      };


      // 根据未读状态分类
      (contact.unread ? offlineMap : historyList).push(contact);
    });

    // 按最后消息时间倒序排列
    const sortByLastTime = (a, b) =>
      new Date(b.lastMessageTime) - new Date(a.lastMessageTime);

    // 更新Vuex状态
    commit('SET_OFFLINE_CONTACTS', Object.values(offlineMap).sort(sortByLastTime));
    commit('SET_HISTORY_CONTACTS', historyList.sort(sortByLastTime));
  },

  // 发送聊天消息
  async sendChatMessage({ state, rootState, commit }, { toUserId, content, fromRole, toRole }) {

    const socket = getSocketInstance();

    if (!state.socket || state.socket.readyState !== WebSocket.OPEN) {
      throw new Error('WebSocket 连接未建立');
    }

    const currentTime = formatTime();
    const userInfo = fromRole === "seeker" ? rootState.seeker.userInfo : rootState['recruiter'].userInfo;

    const message = {
      fromUserId: userInfo.userId,
      toUserId: toUserId,
      fromRole: fromRole,
      message: content,
      messageType: "TEXT",
      createdAt: currentTime,
      toRole: toRole
    };

    const tempId = Date.now();
    const tempMessage = { ...message, tempId };
    commit('ADD_MESSAGE_TO_SELECTED', tempMessage);

    try {
      if (socket.readyState !== WebSocket.OPEN) {
        throw new Error('WebSocket 连接未打开');
      }
      socket.send(JSON.stringify(tempMessage));

      // 关键：设置超时机制
      await new Promise((resolve, reject) => {
        // 监听连接关闭事件（若在超时前连接关闭，视为失败）
        const handleClose = () => {
          socket.removeEventListener('close', handleClose);
          reject(new Error('WebSocket 连接关闭'));
        };
        socket.addEventListener('close', handleClose);

        // 3秒后若无异常，认为发送成功
        setTimeout(() => {
          socket.removeEventListener('close', handleClose);
          resolve();
        }, 3000);
      });

      commit('UPDATE_MESSAGE_STATUS', { tempId, status: 'success' });
      return tempMessage;

    } catch (error) {
      console.error('发送失败', error);
      // 发送失败：回滚（移除临时消息或标记失败）
      commit('ROLLBACK_MESSAGE', tempId);
      throw error;
    }
  },

  //处理在线新消息
  handleOnlineMessage({ commit, state, rootState }, newMessage) {
    // 1. 验证消息合法性
    if (!newMessage.fromUserId || !newMessage.message) {
      commit('ADD_SYSTEM_MESSAGE', '系统：收到无效消息（缺少必要字段）');
      return;
    }

    // 2. 直接添加新消息（不再区分消息来源）
    console.log('看看新消息', newMessage);
    commit('ADD_ONLINE_MESSAGE', newMessage);

    // // 新增：触发通知
    // const currentUserId = rootState[rootState.userType].userInfo.userId;
    // const isCurrentChat = state.selectedContact?.id === newMessage.fromUserId;

    // // 如果消息不是当前用户发出的，并且不在当前聊天窗口中，则显示通知
    // if (newMessage.fromUserId !== currentUserId && !isCurrentChat) {
    //   const senderName = newMessage.fromRole === 'seeker' ? '求职者' : '招聘者';
    //   commit('ADD_NOTIFICATION', {
    //     title: `${senderName} ${newMessage.fromUserId}`,
    //     message: newMessage.message,
    //     type: 'info'
    //   });
    // }
  },

  // 添加通知 action
  addNotification({ commit }, { title, message, type = 'info' }) {
    commit('ADD_NOTIFICATION', { title, message, type, timestamp: new Date() });

    // 3秒后自动清除通知
    setTimeout(() => {
      commit('CLEAR_NOTIFICATION', Date.now());
    }, 3000);
  }
};

export default {
  namespaced: true,
  state,
  getters,
  mutations,
  actions
};